public class Main {
    public static void main(String[] args) {
        //System.out.println("hello world!");    打印hello world

        //语法格式
        /*int a = 10;  //定义整型变量a,a是变量名也称为标识符,该变量中放置的值为10
        double b = 3.14;
        char c = 'A';
        boolean d = true;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);*/

        //整型变量
        //方式一:在定义时给出初始值
        //int a = 10;
        //System.out.println(a);

        //方式二:在定义时没有给初始值,但使用时前必须设置初值
        //int b;
        //b = 10;
        //System.out.println(b);

        //使用方式二定义后,在使用前如果没有赋值,则编译期间会报错
        //int c;
        //System.out.println(c);
        //c = 100;

        //int型变量所能表示的范围:
        //System.out.println(Integer.MIN_VALUE);
        //System.out.println(Integer.MAX_VALUE);

        //注意:在定义int型变量时,所赋值不能超过int的范围
        //int d = 12345678901234;//编译时报错,初值超过了int的范围




        /*长整型变量
        int a = 10;
        long b = 10; //long定义的长整形变量

        long c = 10L;//为了区分int和long类型,一般建议:long类型变量的初始值之后加L或l
        long d = 10L;//一般更加以加大写的L ,因为小写的l与1不好区分

        //long型变量所能表示的范围:这个数据范围远超过int的表示范围.足够绝大部分的工程场景使用
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);*/
        //long范围为-2^63----2^63-1


/*
        //短整型变量
        short a = 10;
        System.out.println(a);

        //short型变量所能表示的范围:-32768 ~ 32767
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);





        //字节型变量
        byte b = 10;
        System.out.println(b);

        //byte型变量所能表示的范围:-128 ~ 127
        System.Out.println(Byte.MIN_VALUE);
        System.Out.println(Byte.MAX_VALUE);





        浮点型变量
         double d = 3.14;
        System.out.println(d);

        例子1:
        int a = 1;
        int b = 2;
        System.out.println(a/b);//输出0.5吗?

        //在Java中, int除以int的值仍然是int(会直接舍弃小数部分)。如果想得到 0.5, 需要使用 double 类型计算

        double a = 1.0;
        double b = 2.0;
        System.out.println(a/b);//这才是输出0.5

        例子2:
        double num = 1.1;
        System.out.println(num*num);//输出1.21吗?
        //执行结果
          1.2100000000000002

        /*double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势
        必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。*/





       /* 字符型变量
        char c1 = 'A';
        char c2 = '1';
        System.out.println(c1);
        System.out.println(c2);

        //注意:java中的字符可以存放整形
        char c3 = '帅';
        System.out.println(c3);
*/



        /*布尔型变量
        //布尔类型常用来表示真假，在现实生活中也是经常出现的，比如：听说xxx同学买彩票中了一个亿...，听到后估计
        //大部分人第一反应就是：我c，真的假的？

        boolean b = true;
        System.out.println(b);//真

        b = false;
        System.out.println(b);//假




        类型转换
        //Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验
        int a = 10;
        long b = 100L;
        b = a;//可以通过编译
        a = b;//编译失败

        //注:int型变量的范围比long型的变量发范围小.转换规则是小范围才能转到大范围
        //因此int中的a可以转成long中的a,而long中的b不能转换成int中的b

//在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式) 和 强制类型转换(显式)。


        /*自动类型转换(隐式)
        自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数
        据范围大的时会自动进行。*/

        /*System.out.println(1024);//整形默认情况下是int
        System.out.println(3.14);//浮点型默认情况下是double


        int a = 100;
        long b = 10L;
        b = a;//a和b都是整形,a的范围小,b的范围大,但将a赋值给b时,编译器会自动将a提升为long类型,然后赋值
        a = b;//编译报错,long的范围比int的范围大,会有数据丢失,不安全

        float f = 3.14F;
        double d = 5.12;
        d = f;//编译器会将f转换为double,然后进行赋值
        f = d;//double表示数据范围大,直接将float交给double会有数据丢失,不安全


        byte b1 = 100;//编译通过,100没有超过byte的范围(-128 ~ 127),编译器隐式将100转换为byte
        byte b2 = 257;//编译失败,257超过了byte的数据范围,有数据丢失
        */




        /*强制类型转换(显式)
        强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小 的。
        但是强转可能精度丢失
        int a = 10;
        long b = 100L;
        b = a;//int-->long,  数据范围由小到大,隐式转换
        a = (int)b;// long-->int,数据范围由大到小,需强转,否则编译失败

        float f = 3.14F;
        double d = 5.12;
        d = f;//float-->double,数据范围由小到大,隐式转换
        f = (float)d;//double-->float,数据范围由大到小,需要强转,否则编译失败

        a = d;//报错,类型不兼容
        a = (int)d;//int没有double表示的数据范围大,需要强转,小数点之后全部丢弃


        byte b1 = 100; //100默认为int,没有超过byte范围,隐式转换(自动)
        byte b2 = (byte)257; //257默认为int,超过byte范围,需要显示转换,否则报错

        boolean falg = true;
        a = flag;//编译失败,类型不兼容
        flag = a;//编译失败,类型不兼容





        类型提升
        //不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。
        1.int与long之间:int会被提升为long
            int a = 10;
            long b = 20;
            int c = a + b;//编译出错,a+b-->int+long-->long+long-->赋值给int c(大范围i给小范围)时会丢失数据
            long d = a + b;//编译成功:a+b-->int+long-->long+long-->赋值给long


        2.byte与byte的运算
        byte a = 10;
        byte b = 20;
        byte c = a+b;//计算a+b时会先将a和b都提升成int,在进行计算,得到的结果也是int,再赋值给c(int-->byte,大赋值给小,报错)
        System.out.println(c);
        //编译报错
        //Test.java:5:错误:不兼容类型,从int转换到byte可能会有损失
        //byte c = a+b;

        正确的写法:
        byte a = 10;
        byte b = 20;
        byte c =(byte)(a+b);
        System.out.println(c);





        字符串类型
        在Java中使用String类定义字符串类型，比如：
        public static void main(String[] args) {
            String s1 = "hello";
            String s2 = " world";
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
        }

        //在有些情况下，需要将字符串和整形数字之间进行转换：
        1.int转换成String
            int num = 10;
        //方法一
        String str1 = num + "";

        //方法二
        String str2 = String.valueOf(num);


        2.String转成int
            String str = "100";
        int num = Integer.parsenlnt(str);
*/




    }
}



